BBS Toolkit/BBS Toolkit.iso/rbbs_pc/msgtos20.zip/SPAZ_150.LZH/SPAZ.ASM

Assembly Source File | 1990-10-07 | 67KB | 2,044 lines

;---------------------------------------------------------------------;
;                                                                     ;
;                               SPAZ 1.50                             ;
;                            October 7, 1990                          ;
;                                                                     ;
;           By Dan Thomson, Andrew Farmer and Jeffrey Nonken.         ;
;                                                                     ;
;                                                                     ;
;                              SOURCE CODE                            ;
;                                                                     ;
;                                                                     ;
;         Copyright (c) 1989-1990 Dan Thomson and Andrew Farmer.      ;
;                         All Rights Reserved.                        ;
;                                                                     ;
;---------------------------------------------------------------------;

name    SPAZ
page    60,132
title    Smart Pak, Arc and Zoo Shell

false    equ    00h
tab    equ    09h                ;ASCII tab
lf    equ    0ah                ;ASCII line feed
cr    equ    0dh                ;ASCII carriage return
blank    equ    20h                ;ASCII blank
arc_len    equ    21h                ;Only save info for sort
DOS    equ    21h                ;DOS int call
CntrolC    equ    23h                ;Control C checking...
cmdtail    equ    80h                ;Offset to command tail
true    equ    255
bsize    equ    4096                ;Size of copy buffer

; If you have lots of memory, (Not running a multi-tasker) then the
; following variables can be changed to allow running SPAZ a little
; faster, but using alot more memory....

; 1. Entries is the number of members in a standard ARC file that
;    can be stored for sorting. If an ARC has more than 150, the
;    file is not sorted. This can be increased until buffers reach
;    (64K - code size). Each entry needs 29 bytes of buffer space.

Entries        equ    150

; 2. This entry controls how many file names will be stored in
;    memory. This is used during wild card processing to run
;    SPAZ on each individual name. It has been set at 30 to
;    allow most systems to run without writing to disk. If you
;    run a busy mail system or process alot of archives, this
;    can be increased (at the cost of memory) for faster processing.

NamesFound    equ    30

;DOS interupt equates...

CharacterOutput        equ    02h
OutputString        equ    09h
SetDTA            equ    1ah
SetVector        equ    25h
GetVector        equ    35h
CreateFile        equ    3ch
OpenFile        equ    3dh
CloseFile        equ    3eh
ReadFile        equ    3fh
WriteFile        equ    40h
DeleteFile        equ    41h
MoveFilePointer        equ    42h
GetOrSetAttribute    equ    43h
ModifyMemory        equ    4ah
ExecuteProgram        equ    4bh
ExitWithCode        equ    4ch
GetReturnCode        equ    4dh
SearchForFirst        equ    4eh
SearchForNext        equ    4fh
RenameFile        equ    56h

cseg    segment    para public 'code'
    assume    cs:cseg,ds:cseg,es:cseg,ss:cseg

    org    100h                ;Skip to end of the PSP
entry:    jmp    start                ;comm file entry always 0100H

TitleScreen    db    cr,lf,'SPAZ 1.50; Written by Dan Thomson, Andrew Farmer and Jeffrey Nonken.',cr,lf
        db          'Copyright (c) 1989-1990 Dan Thomson & Andrew Farmer.  All Rights Reserved.',cr,lf
TitleLength    equ    $-TitleScreen

Usage    db    cr,lf,'Syntax/Usage: SPAZ [switches] Path\Archive [switches] [files....]'
    db    cr,lf,'Square brackets indicate optionals. Switches are set with - or /.'
    db    cr,lf,cr,lf,'Switches:',cr,lf,cr,lf
    db    '  -A       Will use ONLY "ARCE" on standard (ARC Style) archives.',cr,lf
    db    '  -D       Will delete the archive if the extract was successful.',cr,lf
    db    '  -F       Will process all Compressed Mail bundles found in Dir.',cr,lf
        db      '  -Maddr   Will calculate Compressed Mail bundle name to show the',cr,lf
        db      '           sending Net Address.  "addr" is YOUR Net/Node address.',cr,lf
    db    '  -N       Will NOT attempt to sort the archive prior to extract.',cr,lf
    db    '  -O|-R    Overwrite.  Will NOT prompt if existing file is found.',cr,lf
    db    '  -V       Verbose Mode.  Will display the runtime configuration.',cr,lf,cr,lf
    db    'If -F is used then "Archive" MUST be a Path ONLY, not a Filename.',cr,lf
        db      'Use of -F forces -D and -O to be set TRUE and -N to be set False.',cr,lf
UsageLength    equ    $-Usage

    even
errmsg    dw    err2,err2,err2,err4,err5,err13
    dw    err13,err8,err8,err10,err11,err5
    dw    err13,err15,err15,err2,err2,err2
    dw    err20,err20,err21,err22,err23,err24,err25

err2    db    cr,lf,'File not found: ',0
err4    db    cr,lf,'Too many open files.',cr,lf,0
err5    db    cr,lf,'Access denied.',cr,lf,0
err8    db    cr,lf,'Insufficient memory.',cr,lf,0
err10    db    cr,lf,'Invalid environment.',cr,lf,0
err11    db    cr,lf,'Invalid format.',cr,lf,0
err13    db    cr,lf,'Invalid data.',cr,lf,0
err15    db    cr,lf,'Invalid drive was specified.',cr,lf,0
err20    db    cr,lf,'Invalid file format, not changed.',cr,lf,0
err21    db    cr,lf,'Too many archive entries.',cr,lf,0
err22    db    cr,lf,'Unarchiver not found on path.',cr,lf,0
err23    db    cr,lf,'Invalid Command Line Option used.',cr,lf,0
err24    db    cr,lf,'Archive name not specified!',cr,lf,0
err25    db    cr,lf,'Invalid directory specified.',cr,lf,'$'
NoMail    db    cr,lf,'No Compressed Mail Bundles Found in Directory!',cr,lf,cr,lf,'$'
SortErr    db    'Sort failed, attempting extract anyway...',cr,lf,0
zerr    db    'Problem reading archive for type check.',cr,lf,0
crlf    equ    $-3
TempErr    db    'Unable to process temporary file, aborting.',cr,lf,'$'
del_msg    db    cr,lf,'Extract successful - Unlinking ',0
will    db    cr,lf,'Will ',0
wont    db    cr,lf,'Will NOT ',0
info1    db    'use ARCE on standard (ARC style) archives.',0
info2    db    'delete the archives if extract was successful.',0
info3    db    'attempt to sort the archives.',cr,lf,0
info4    db    ' - From: ',0
info5    db    'expand network addresses.',0
info6    db    'process Compressed Mail bundles ONLY.',0
info7    db    'operate in overwrite mode.',0

msg1    db    ' Adjusting: ',0
msg2    db    '- Location = ',0
msg3    db    '   Length = ',0
msg4    db    'Searching: ',0

UnArc1    db    'PKXARC.EXE',0
UnArc2    db    'PKXARC.COM',0
UnArc3    db    'PKUNPAK.EXE',0
UnArc4    db    'LOOZ.EXE',0
UnArc5    db    'PAK.EXE',0
UnArc6    db    'ARCE.COM',0
UnArc7    db    'ZOO.EXE',0
UnArc8    db    'DWC.EXE',0
UnArc9    db    'PKUNZIP.EXE',0
UnArc10    db    'LHARC.EXE',0

on_disk        db    0            ;True if names on disk    .jjn
num_names    db    0            ;# of filenames in buffer .jjn
num_hdr        db    0            ;Number of headers input
first        db    true            ;Flag for search first/next
flag        db    false            ;Show sort done on pass
Zooflag        db    false            ;Flag to signify zoo file
Crushed        db    false            ;Flag to signify crushed files
A_Flag        db    false            ;Set no default archiver
D_Flag        db    false            ;Set no delete when finished
F_Flag        db    false            ;Set no mail only stuff
M_Flag        db    false            ;Show net/node on extract?
N_Flag        db    true            ;Set default sort performed
O_Flag        db    false            ;Set default to non-overwrite
Q_Flag        db    true            ;Set default to quiet
IsZip        db    false            ;Flag to show ZIP file
IsDWC        db    false            ;Flag to show DWC file
IsLZH        db    false            ;Flag to show LZH file
Parsed        db    false            ;Flag to show names were parsed
Got_name    db    false            ;Cmd line fname is OK...
Characters    db    false            ;Print string char counter
Last_Chance    db    false            ;Flag for Arce useage
elevel        db    0            ;Last reported error level
count        db    0            ;Number of passes complete
order        db    0            ;Flag to show archive in order
temp        db    'SpazTmp1.$$$',0    ;Temp filename to use
thomlen    equ    $-temp                ;                          .jjn
filename_file    db    'SpazTmp2.$$$',0    ;Filename for list of files
end_arc        db    1Ah,0            ;Mark to show end of arc
    even
arg_len        dw    0            ;Length of command line arg
buf_pos        dw    0            ;Position in header buffer
endpath        dw    0            ;Holds end of path address
pathlen        dw    0            ;Holds length of path      .jjn
files_handle    dw    0            ;Handle for filespec file  .jjn
name_count    dw    0            ;Number of filenames found .jjn
names_used    dw    0            ;Number of names used after.jjn
                        ; all the names were found .jjn
fname_ptr    dw    0            ;Point into filename buffer.jjn
Opt_Address    dw    false            ;Pointer to cmd line fname
Opt_Length    dw    false            ;Address of cmd line fname
high_pos    dw    0            ;High byte of file pointer
low_pos        dw    0            ;Low byte of file pointer
in_handle    dw    0            ;Handle for read file
out_handle    dw    0            ;Handle for write file


par_blk    dw    0                ;Copy of parent's environment
    dw    offset cmd_cnt            ;Pointer to command line
sg1    dw    0
    dw    offset    fcb1
sg2    dw    0
    dw    offset     fcb2
sg3    dw    0

stk_seg        dw    0            ;Saved stack segment
stk_ptr        dw    0            ;Saved stack pointer
dir        dw    0            ;Pointer for PATH search
enddir        dw    0            ;End address of PATH variable
cmd1_cnt    dw    0            ;Length of wildcard filename
env_len        dw    0            ;Length of PATH in Environment
BundlePosition    dw    offset BundleNames    ;Current position for mail
env        db    'PATH',0        ;Environment variable to find
DefaultBundle    db    '*.MO?',0        ;First mail type to look for
BundleNames    db    'TUWETHFRSASU'        ; and the rest of 'em....


Spaz    proc    near                ;Entry point from MS-DOS

start:  mov    AX,CS
    mov    sg1,AX
    mov    sg2,AX
    mov    sg3,AX

    mov    AH,SetDTA            ;AH = Set Disk Tranfer Area
    mov    DX,offset dta_buf        ;Address of scratch space
    int    DOS                ;Give it to DOS

    xor    AX,AX
    mov    word ptr Names_Count,AX
    cli                    ;Disable interupts
    lea    sp,bottom-1            ;Move stack to save position
    sti                    ;OK for interups now...

     mov    DX,offset bottom        ;Point DX to end of Spaz
    mov    BX,DX                ;Info needed in BX
    add    BX,0fh                ;Add 1 paragraph to it
    mov    CL,4                ;CL = counter for shift
    shr    BX,CL                ;= BX/16 (# of paras needed)
    mov    AH,ModifyMemory            ;AH = Modify memory block
    int    DOS                ;Extra memory released...

; First, identify self and examine parameters...

    mov    DX,offset TitleScreen        ;DX points to message
    mov    BX,2                ;Output to standard error
    mov    CX,TitleLength            ;Length of header string
    mov    AH,WriteFile            ;Output to handle
    int    DOS                ;Call DOS to do it
    mov    SI,offset env            ;Search for 'PATH'
    mov    es,es:[2ch]            ;Get environment segment
    call    getenv                ;Read in PATH string

    mov    BX,cmdtail            ;ES:BX = command parameters
    call    argc                ;Get number of arguments
    cmp    AX,2                ;At least 1 argument?
    jae    args_ok                ;If yes, keep going

Syntax:    mov    DX,offset Usage            ;DX points to usage string
    mov    BX,2                ;Output to standard error
    mov    CX,UsageLength            ;Length of usage string
    mov    AH,WriteFile            ;Output to handle
    int    DOS                ;Call DOS to do it
    mov    AL,0                ;Errorlevel 0 exit
    mov    AH,ExitWithCode            ;AH = Terminate to DOS
    int    DOS                ;Transfer to DOS (for good)

args_ok:
    call    options                ;Scan off any options

; Here, ES:BX = argument address and AX = argument length

    cld                    ;Direction register increments
    mov    SI,BX                ;Point SI to argument
    lea    DI,cmd1                ;DI = destination
    mov    CX,AX                ;Put character count in CX
    mov    cmd1_cnt,AX            ;And save it for later!
    rep movsb                ;Move argument to buffer

; End the filename (or PATH if -F used) with a zip.

    mov    byte ptr [DI],0

; Here, we check for a -F option. If it is true, we tack on the
; default filename (*.MO?) and start a mail run.

    cmp    F_Flag,true            ;Is this a mail run?
    jne    NotAMailRun            ;Nope, continue

    cmp    byte ptr [DI-1],'\'        ;Did they have backslash?
    je    AddName                ;If yes, do the name
    mov    byte ptr [DI],'\'        ;Else add a slash
    inc    word ptr cmd1_cnt        ;And bump counter
    inc    DI                ;Adjust pointer
AddName:
    mov    byte ptr [DI-1],0        ;Make it ASCIIZ
    mov    DX,offset cmd1            ;Point to filename/path
    mov    AX,4300h            ;Get attribute
    int    DOS                ;Call DOS to do it
    mov    byte ptr [DI-1],'\'        ;Restore back slash
    and    CX,00010000b            ;Is this a directory?
    jnz    DirectoryFound            ;Go if yes.
    mov    DX,offset err25            ;Invalid directory message
    mov    AH,OutputString            ;DOS print string function
    int    DOS                ;Call DOS to do it
    jmp    syntax                ;Display syntax screen

DirectoryFound:
    mov    SI,offset DefaultBundle        ;Point to bundle name
    mov    CX,3                ;Count for name length
    rep    movsw                ;Stuff name in buffer
    add    cmd1_cnt,6            ;Fix the counter
    jmp    short Isolate            ;No need to check it now

; Here, we will check to make sure there is a valid extension.
; If none was given, a default extention of '.*' will be added.

NotAMailRun:
    std                    ;Set up to move backwards
    mov    SI,offset cmd1            ;Get address of filename
    mov    DI,SI                ;So we can check for end
    mov    AX,cmd1_cnt            ;Get length in AX
    add    SI,AX                ;Point to end of filename
    push    SI                ;Save end address
scan:    lodsb                    ;Get a character
    cmp    AL,'.'                ;Is it a period?
    je    ExtentionIsOk            ;If yes, extention OK
    cmp    AL,'\'                ;Is it filename separater?
    je    UseDefault            ;Stop if yes
    cmp    DI,SI                ;Scanned whole name?
    jne    scan                ;No, go get more
UseDefault:
    pop    DI                ;DI = end address of filename
    mov    byte ptr [DI],'*'        ;Add full wildcard search
    mov    byte ptr [DI+1],'.'        ;Add a dot to filename
    mov    byte ptr [DI+2],'*'        ;Add wildcard extension
    mov    byte ptr [DI+3],0        ;End it with a zip
    add    word ptr cmd1_cnt,3        ;Adjust length count
    push    DI                ;Maintain stack balance

; Next, we isolate the path from the filename so that successive
; filenames can be tacked onto it in case wildcards are used...

    public    ExtentionIsOk
ExtentionIsOk:
    add    SP,2                ;Remove garbage from stack

Isolate:
    call    show_opt            ;Display option info
    std                    ;Set up to move backwards
    mov    SI,offset cmd1            ;Get address of filename
                        ;so we can check for a path.jjn
    mov    CX,cmd1_cnt            ;Get length in CX          .jjn
    add    SI,CX                ;SI = end of filename      .jjn
    dec    SI                ;                          .jjn
    public    path1
path1:    lodsb                    ;Get a character
    cmp    AL,'\'                ;Filename separator?
    je    save_path            ;Stop if yes
    cmp    AL,':'                ;Drive separator?
    je    save_path            ;Stop if yes
    loop    path1                ;Decrement and loop        .jjn
    inc    SI
    mov    endpath,SI            ;Save address
    mov    pathlen,CX            ;Save path length (0)      .jjn
    jmp    short _end_p            ;Skip double save          .jjn
    public    save_path
save_path:
    inc    SI                ;Adjust past \ character
    inc    SI                ;Need 2 for auto dec...
    mov    endpath,SI            ;Save address of end of path
    mov    pathlen,CX            ;Save path length          .jjn
_end_p:                        ;                          .jjn
    cld                    ;Set direction forward
;
; Now we call the wildcard expander. This creates a list of filenames that
; match the filespec so we can retrieve them later. If there are more than
; 'NamesFound' matches, it will save them on disk.
;
    mov    on_disk,0            ;List of files is not on disk
    mov    Name_count,0            ;No names found yet
    mov    num_names,0
DoAllMail:
    call    FindNames            ; Find all matching files  .jjn
    cmp    F_Flag,true            ;Are we doing a mail run?
    jne    NotDoingMail            ;Go if not

    mov    SI,BundlePosition        ;Get address for bundle name
    cmp    SI,offset SPAZ            ;No more names to do?
    je    NotDoingMail            ;If not, we're done...
    lodsw                    ;Get next bundle name
    mov    DI,EndPath            ;End of path to filename
    add    DI,2                ;Adjust to right spot
    stosw                    ;And stuff in new name
    mov    BundlePosition,SI        ;Save new name offset
    jmp    short DoAllMail            ;And get more filenames

NotDoingMail:
    cmp    on_disk,0            ;Is stuff on disk?
    jz    NothingOnDisk            ;Nope skip pointer adjust
    mov    AH,MoveFilePointer        ;Move pointer DOS function
    xor    CX,CX                ;Offset from beginning of file
    mov    DX,CX                ;32 bit
    mov    AL,CL                ;Mark for 'beginning'
    mov    BX,files_handle            ;Get the file handle
    int    DOS                ;Call DOS to do it
NothingOnDisk:
    mov    AX,name_count            ; number of names found
    or    AX,AX                ; return with zero flag set
    jnz    Main                ; skip error stuff         .jjn

; If we got here, there were no names found.
; (Moved from the old wild_card procedure. .jjn)

    cmp    F_Flag,true            ;Was this a mail run?
    jne    NormalNotFound            ;If not, do normal exit
    mov    DX,offset NoMail        ;Mail run error message
    mov    AH,OutputString            ;DOS print string function
    int    DOS                ;Call DOS to do it
    jmp    short DoneTotally        ;Denis Miller time
NormalNotFound:
    mov    AX,2                ;Change error to file not found
    call    err_msg                ;Display error in english
    push    AX                ;Save error code
    mov    SI,offset cmd1            ;Point to filename
    call    upper                ;Convert to upper case
    call    ShowIt                ;Show it (not found)
    mov    SI,offset crlf            ;CR,LF
    call    ShowIt                ;On screen
    pop    AX                ;Restore error code
DoneTotally:
    mov    AH,ExitWithCode            ;Terminate with code
    int    DOS                ;Exit program

; This is the main loop of the program. It is run once for every
; matching filename found from the command line. Needed variables
; are reset each time through.

Main:
    mov    zooflag,false            ;Reset variables
    mov    byte ptr cmd_cnt,9
    mov    crushed,false
    mov    word ptr buf_pos,0
    mov    flag,false
    mov    count,false
    mov    order,false
    mov    num_hdr,false
    mov    IsZip,false
    mov    IsDWC,false
    mov    IsLZH,false
    mov    Last_Chance,false

    mov    DI,offset ExtractOptions    ;Point to last set of options
    mov    CX,9                ;Max options set at 5 bytes
    mov    AL,blank            ;Blank them out (spaces)
    rep    stosb

    mov    SI,offset crlf            ;Cr,Lf between runs
    call    ShowIt
    call    wild_card            ;Grab a filename to work on

; If we return from wild_card, at least 1 matching filename was found.
; Otherwise the program reports its status and quits. If a wild card
; was used, it has now been extended to a fully qualified filename. Now
; it has to be checked for archive type etc. etc.

    mov    SI,offset msg4            ;SI = 'Searching:'
    call    ShowIt                ;Put it on screen
    mov    SI,offset cmd1            ;SI = filename
    call    upper                ;Convert it to upper case
    call    ShowIt                ;Put it on screen
    cmp    M_Flag,true            ;Displaying net/node?
    jne    NoAddress            ;Skip next part if not
    call    DisplayNode            ;Figure out the info
    mov    SI,offset info4            ;From message
    call    ShowIt                ;Display it
    mov    SI,offset BuildNet        ;Our ASCII info
    call    ShowIt                ;Display it
NoAddress:
    mov    SI,offset crlf            ;SI = cr/lf
    call    ShowIt                ;On screen

    mov    SI,offset cmd1            ;SI = full filename
    mov    DI,offset pakfile        ;DI = new command line
do_count:
    lodsb                    ;Get a character from line
    cmp    AL,0                ;End of filename?
    je    done                ;yes, we are finished
    cmp    AL,cr
    je    done1
    inc    byte ptr cmd_cnt        ;Else, bump character counter
    stosb                    ;Save char in command line
    jmp    short do_count            ;and loop back...

done:    mov    AL,cr                ;Cmd line must end with cr
done1:    stosb                    ;Stuff final character

    mov    byte ptr [DI],0            ;make it ASCIIZ ***

; This little section adds any unique file names that are to be
; extracted from the archive. If this option is used in conjunction
; with /d, the archive will be deleted after extraction. BE CAREFUL

    cmp    Parsed,true            ;Were filenames specified?
    jne    No_Parsed            ;Skip this if not
    dec    DI                ;Back up destination pointer
    mov    SI,offset Extract_Names        ;SI = extract name buffer
    mov    CX,word ptr Names_Count        ;Get length of names
    add    byte ptr cmd_cnt,CL
    rep    movsb                ;Set up the line
    mov    byte ptr [DI],cr        ;End it all with a cr
    mov    byte ptr [DI+1],0        ;Make it ASCIIZ

; Here is where we check the archive type. If it is a zoo file, it is
; extracted as is. If it is an ARC/PAK/PK file, it is first checked to
; ensure that it is in proper order by date time...

No_Parsed:
    call    ArchiveCheck            ;Check the archive type
    jnc    Zoo_Check_OK            ;If all is well, continue
    jmp    main                ;Else, try to do the next one

Zoo_Check_OK:
    mov    DX,offset UnArc4        ;Point to LOOZ.EXE
    cmp    zooflag,true            ;Is this a zoo file?
    jne    no_zoo
    call    find                ;Does LOOZ exist?
    jc    no_looz                ;Nope, check for zoo

; If execution falls here, LOOZ was found on the path. We have to change
; the extract option to 'x' as looz does not understand 'e'

    cmp    O_Flag,true            ;Do we want forced overwrite?
    jne    DontForceLooz            ;Go if not
    jmp    short no_looz            ;If we do, call zoo instead
DontForceLooz:
    mov    byte ptr ExtractOptions + 1,'x'    ;Change extract option
    jmp    X_OK                ;Go execute looz

; If we get here, a zoo archive was detected, and LOOZ was not found.
; Check for ZOO.EXE and quit if not found...

no_looz:
    mov    DX,offset UnArc7        ;DX = zoo.exe
    cmp    O_Flag,true            ;Do we want forced overwrite?
    jne    DoNotForceZoo            ;Exit if not, else
    mov    byte ptr ExtractOptions +2,'S'    ;This will force overwrite
    mov    byte ptr ExtractOptions +3,'O'    ;This is needed too
DoNotForceZoo:
    mov    byte ptr ExtractOptions +1,'x'    ;Change extract option
    jmp    zoo                ;Go hunt for it

no_zoo:    cmp    IsDWC,true            ;Is this a DWC file?
    jne    TryZIP                ;Nope, check for ZIP
    mov    DX,offset UnArc8        ;Point to 'DWC.EXE'
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DoNotForceDwc            ;If not, exit
    mov    byte ptr ExtractOptions + 1,'x'    ;This will allow DWC
    mov    byte ptr ExtractOptions + 2,'w' ;to overwrite existing files
    jmp    Zoo                ;Try to run it
DoNotForceDwc:
    mov    byte ptr ExtractOptions + 1,'e'    ;Normal extract mode
    jmp    Zoo                ;Try to run it

TryZIP:    cmp    IsZIP,true            ;Is this a ZIP file?
    jne    TryLZH                ;If not, check for LHArc
    mov    DX,offset UnArc9        ;Point to 'PKUNZIP.EXE'
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DoNotForceZIP            ;Exit if not
    mov    byte ptr ExtractOptions + 1,'-'    ;This will allow Zip
    mov    byte ptr ExtractOptions + 2,'o'    ;to overwrite existing files
    jmp    Zoo                ;Try to run it
DoNotForceZIP:
    jmp    Zoo                ;Try to run it

TryLZH:    cmp    IsLZH,true            ;Is this an LHZ file?
    jne    TryNormal            ;Must be an ARC
    mov    DX,offset UnArc10        ;Point to 'LHARC.EXE'
    mov    byte ptr ExtractOptions,'e'    ;Must have extract option
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DoNotForceLZH            ;Exit if not
    mov    byte ptr ExtractOptions + 2,'/'    ;This will allow LHArc
    mov    byte ptr ExtractOptions + 3,'m'    ;to overwrite existing files
    mov    byte ptr ExtractOptions + 4,'c'    ;Not very exotic....
    jmp    Zoo                ;Try to run it
DoNotForceLZH:
    jmp    Zoo                ;Try to run it

TryNormal:
    call    Sort_It
    jnc    part2                ;Sort was good, go unarc

    mov    SI,offset sorterr        ;Point to error message
    call    ShowIt                ;Put it on screen

Part2:
    mov    byte ptr ExtractOptions + 1,'e'    ;Normal extract option
    cmp    Crushed,true            ;Crushed files?
    jne    part3                ;Nope, check for ARCE

Part2a:    mov    DX,offset UnArc5        ;Point to PAK.EXE
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DoNotForcePak            ;Exit if not
    mov    byte ptr ExtractOptions + 2,' ' ;A space for the new PAK
    mov    byte ptr ExtractOptions + 3,'/' ;A hyphen for the new PAK
    mov    byte ptr ExtractOptions + 4,'w' ;This tells pak to force
    mov    byte ptr ExtractOptions + 5,'a' ; overwrites always
DoNotForcePak:
    cmp    byte ptr D_flag,true        ;Was delete flag set?
    jne    NoDelete            ;Nope, continue...
    mov    byte ptr ExtractOptions + 1,'x'    ;Delete archive when done
NoDelete:
    jmp    zoo                ;Do PAK and PAK only.

part3:    cmp    byte ptr A_Flag,true        ;Default to ARCE?
    jne    Xarc                ;Go if not

NoneFound:
    cmp    Crushed,true            ;Crushed files?
    jne    OkForArce            ;Nope, keep going
    jmp    Give_Up                ;If yes, just quit
OkForArce:
    cmp    O_Flag,true            ;Force overwrite mode?
    jne    DontForceArce            ;Go if not

    mov    SI,offset pakfile        ;Point to command line
goagain:
    lodsb
    or    AL,AL
    jnz    goagain
    mov    DI,SI                ;Get address in DI
    mov    byte ptr [DI-2],Blank        ;Put in a space
    mov    byte ptr [DI-1],'/'        ;and an Option delimiter
    mov    byte ptr [DI],'R'        ;and Force overwrites...
    mov    byte ptr [DI+1],cr
    mov    byte ptr [DI+2],0
    add    byte ptr cmd_cnt,3        ;Fix the count up

DontForceArce:
    mov    DX,offset UnArc6        ;Else point to it
    mov    byte ptr ExtractOptions + 1,' '    ;This removes any options
    mov    byte ptr ExtractOptions + 2,' '    ; that may have been put
    mov    byte ptr ExtractOptions + 3,' '    ; in by other un-archers
    jmp    short zoo            ;Go try to run it

Xarc:    mov    DX,offset UnArc1        ;Point to PKXARC.EXE
    mov    byte ptr ExtractOptions + 1,' '    ;Remove 'e' option
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DoNotForceXarc            ;Exit if not
    mov    byte ptr ExtractOptions + 1,'-'    ;This forces PKWare to use
    mov    byte ptr ExtractOptions + 2,'r'    ; it's overwrite mode
DoNotForceXarc:
    call    find                ;See if it exists
    jnc    X_OK                ;Got it!

    mov    DX,offset UnArc2        ;Point to PKXARC.COM
    call    find                ;See if it exists
    jnc    X_OK                ;Got it!

    mov    DX,offset UnArc3        ;Point to PKUNPAK.EXE
    call    find                ;See if it exists
    jnc    X_OK                ;Got it, keep going

    mov    DX,offset UnArc5        ;Point to PAK.EXE
    mov    byte ptr ExtractOptions + 1,'e'    ;Set up extract for pak
    cmp    O_Flag,true            ;Overwrite mode?
    jne    DontForcePak            ;Exit if not
    mov    byte ptr ExtractOptions + 2,' ' ;A space for the new PAK
    mov    byte ptr ExtractOptions + 3,'/' ;A hyphen for the new PAK
    mov    byte ptr ExtractOptions + 4,'w' ;This tells pak to force
    mov    byte ptr ExtractOptions + 5,'a' ;overwrite always
DontForcePak:
    cmp    byte ptr D_flag,true        ;Was delete flag set?
    jne    part3a                ;Nope, continue...
    mov    byte ptr ExtractOptions + 1,'x'    ;Delete archive when done

part3a:    call    find                ;See if it exists
    jnc    X_OK                ;Got it, continue
    jmp    NoneFound            ;Try Arce....

Zoo:    call    find                ;See if it exists
    jnc    X_OK                ;Got it!

; If this code is executed, then no Un-Arc program was found on the
; path. It reports the error and aborts...

Give_Up:
    mov    AX,22                ;Unarcher not found
    call    err_msg                ;Report error in english
    mov    AH,ExitWithCode            ;Exit with code
    int    DOS                ;Back to DOS (for good)

X_OK:    mov    BX,offset par_blk        ;BX points to spawn info
    mov    AL,0                ;AL = load and execute
    push    DS
    push    ES
    cli                    ;Disable interupts
    mov    stk_seg,SS            ;Save the Stack
    mov    stk_ptr,SP            ;Both parts...
    sti                    ;Enable inerupts
    mov    AH,ExecuteProgram        ;AH = MSDOS exec function
    int    DOS                ;Transfer to DOS
    cli                    ;disable interupts
    mov    SS,stk_seg            ;Restore stack segment
    mov    SP,stk_ptr            ;Restore stack pointer
    sti                    ;Enable interupts
    pop    ES
    pop    DS

    mov    AH,GetReturnCode        ;Get return code from Un-Arcer
    int    DOS                ;Transfer to DOS
    mov    elevel,AL            ;Save errorlevel for later

    cmp    byte ptr crushed,true        ;Did we use PAK?
    jne    normal                ;Nope, check for delete flag

    cmp    byte ptr D_Flag,true        ;Did we mark for delete?
    jne    main_loop            ;Exit if no

    mov    SI,offset del_msg        ;SI = 'Unlinking...'
    call    ShowIt
    mov    SI,offset cmd1            ;SI = filename
    call    ShowIt
    mov    SI,offset crlf
    call    ShowIt
    jmp    short main_loop            ;Go do next file

normal:    or    AL,AL                ;Make sure all is well
    jnz    main_loop            ;Before allowing a delete

    cmp    byte ptr D_Flag,true        ;Should we delete arc file?
    jne    main_loop            ;Skip if not

    mov    SI,offset del_msg        ;SI = 'Unlinking...'
    call    ShowIt
    mov    SI,offset cmd1            ;SI = filename
    call    ShowIt
    mov    SI,offset crlf
    call    ShowIt

    mov    AH,DeleteFile            ;AH = delete file
    mov    DX,offset cmd1            ;DX = archive name
    int    DOS                ;Call DOS to do it
    jnc    main_loop            ;Go if no errors
    call    err_msg                ;Show errors but continue...
main_loop:
    jmp    main                ;Go get next file


; Print ASCIIZ string pointed to by SI

ShowIt:
    mov    AH,CharacterOutput        ;Function = console out
    mov    byte ptr Characters,0        ;Set count to zip
show_loop:    lodsb                ;Get a character
    or    AL,AL                ;Is it a 0?
    jz    ShowIt_exit            ;If yes, exit
    inc    byte ptr Characters        ;Bump char counter
    mov    DL,AL                ;ASCII char in DL
    int    DOS                ;Call DOS to print it
    jmp    short show_loop            ;Go get more
ShowIt_exit:
    ret                    ;Return to caller

Spaz    endp

argc    proc    near                ;count command line arguments

    push    BX                ;save original BX and CX
    push    CX                ;  for later
    mov    AX,1                ;force count >= 1
argc1:    mov    CX,-1                ;set flag = outside argument
argc2:    inc    BX                ;point to next character
    cmp    byte ptr [BX],cr
    je    argc3                ;exit if carriage return
    cmp    byte ptr [BX],blank
    je    argc1                ;out of argument if blank
    cmp    byte ptr [BX],tab
    je    argc1                ;outside argument if ASCII tab
                        ;otherwise not blank or tab,
    jcxz    argc2                ;jump if already in argument
    inc    AX                ;else found argument, count it
    not    CX                ;set flag = inside argument
    jmp    argc2                ;and look at next character

argc3:    pop    CX                ;restore original BX and CX
    pop    BX
    ret                    ;return AX = argument count

argc    endp


argv    proc    near                ;get address & length of
                        ;command tail argument
    xor    AH,AH                ;initialize argument countef
argv1:    mov    CX,-1                ;set flag = outside argument
argv2:    inc    BX                ;point to next character
    cmp    byte ptr [BX],cr
    je    argv7                ;exit if carriage return
    cmp    byte ptr [BX],blank
    je    argv1                ;outside argument if ASCII blank
    cmp    byte ptr [BX],tab
    je    argv1                ;outside argument if ASCII tab
                        ;if not blank or tab...
    jcxz    argv2                ;jump if already inside argument
    inc    AH                ;else count arguments found
    cmp    AH,AL                ;is this the one we're looking for?
    je    argv4                ;yes, go find its length
    not    CX                ;no, set flag = inside argument
    jmp    argv2                ;and look at next character

argv4:                        ;found desired argument, now
                        ;determine its length...
    mov    AX,BX                ;save param, starting address

argv5:    inc    BX                ;point to next character
    cmp    byte ptr [BX],cr
    je    argv6                ;found end if carriage return
    cmp    byte ptr [BX],blank
    je    argv6                ;found end if ASCII blank
    cmp    byte ptr [BX],tab
    jne    argv5                ;found end if ASCII tab

argv6:    xchg    BX,AX                ;set ES:BX = argument address
    sub    AX,BX                ;and AX = argument length
    jmp    short argvx            ;return to caller
argv7:    xor    AX,AX                ;set AX = 0, argument not found
argvx:    ret                    ;return to caller

argv    endp


getenv    proc    near                    ; return address and length
                        ;   of environment variable

    push    CX                ; save registers
    push    SI

    mov    CX,8000h            ; assume max env. = 32 KB
    xor    DI,DI                ; initial env. offset
    xor    AX,AX                ; default length result
get1:    cmp     byte ptr ES:[DI],0        ; check for end of environment
    je    get4                ; end reached, return AX = 0
    pop    SI                ; initialize address of target
    push    SI                ;   variable to be found

    repe    cmpsb                ;Compare target and env. strings
    cmp    byte ptr [SI-1],0
    jne    get2                ;Jump if incomplete match
    cmp    byte ptr ES:[DI-1],'='
    je    get3                ;Jump if match was complete

get2:    repne    scasb                ;No match, scan for end string
    jmp    get1                ;Try again to match

get3:    push    DI                ;Save address after = sign
    repne    scasb                ;Look for end of this string
    pop    AX                ;Get back starting address
    xchg    DI,AX                ;Find string length
        sub     AX,DI
    dec    AX                ;Don't include null byte

get4:    pop    SI                ;Common exit point
    pop    CX
    mov    CS:env_len,AX            ;Save PATH length
    or    AX,AX                ;Null PATH?
    jz    get5                ;Exit if yes
    push    ES                ;Get path segment into
    pop    DS                ; DX for string move
    push    CS                ;Now ES points to data
    pop    ES                ; in our code segment
    mov    CX,AX                ;Get length of path in CX
    mov    SI,DI                ;Path is now source
    mov    DI,offset saved            ;Destination is our area
    rep    movsb                ;Move path into this segment
get5:    push    CS                ;Now we have to restore
    pop    DS                ; the original DS
    push    CS
    pop    ES
    ret                    ;Return to caller
getenv  endp


; This routine searches the current directory, and (if needed), the
; entire PATH, looking for an unarchiver to use. It is called with
; DX pointing to an ASCIIZ filename to look for and returns with
; carry clear if it is found. Carry Set if not found.

find    proc    near
    push    DX                ;Save pointer to filename
    mov    AH,SearchForFirst        ;Search for first
    pop    DX                ;Get filename address
    push    DX                ;Save it again
    xor    CX,CX                ;Normal attribute
    int    DOS                ;Give it to DOS
    jc    find1                ;Not found, search path
    pop    DX                ;Point DX to filename
    ret                    ;exit Find...

find1:    mov    AX,env_len            ;Get PATH length
    or    AX,AX                ;Did we find a path?
    jnz    find2                ;Keep going if yes
no_exist:
    pop    DX                ;Point DX to filename
    stc                    ;Carry set to show error
    ret                    ;Exit Find

find2:    mov    DI,offset saved            ;Point to the path string
    mov    dir,DI                ;dir = start of path string
    add    DI,AX                ;AX = end of path string
    mov    enddir,DI            ;save it
    mov    byte ptr [DI],0            ;Null terminator for path

find3:    mov    DI,offset new            ;Area for path\filename
    mov    SI,dir                ;Get current address in path

    cmp    [enddir],SI            ;End of path variable?
    jbe    no_exist            ;Not found, exit

find4:    lodsb                    ;Get a character
    cmp    AL,';'                ;Seperator?
    je    find5                ;Yes, go tack on filename
    cmp    AL,0                ;Are we finished?
    je    find5                ;Yes, go
    stosb                    ;Stuff character
    jmp short find4                ;and go for another

find5:    mov    dir,SI                ;Save current path address
    cmp    byte ptr [DI-1],'\'        ;Path separator?
    je    find6                ;Yup, keep goin
    mov    byte ptr [DI],'\'        ;Else, put one in
    inc    DI                ;Bump the pointer

find6:    pop    SI                ;Get filename address
    push    SI                ;Save it back again

find7:    lodsb                    ;Get character from filename
    cmp    AL,0                ;Got whole filename?
    je    find8                ;Go if yes
    stosb                    ;Else put character in buffer
    jmp    find7                ;Go get the rest

find8:    stosb                    ;Save the null (ASCIIZ)
    mov    AH,SearchForFirst        ;Search for first
    mov    DX,offset new            ;Point to path\filename
    xor    CX,CX                ;Normal attribute
    int    DOS                ;Give it to DOS
    jc    find3                ;Not found try next path
    pop    DX                ;Clear junk off stack
    mov    DX,offset new            ;DX = full path\filename
    clc                    ;Show no errors
    ret                    ;Exit (so we can exec it)
find    endp


; This routine determines what type of archive is being worked on.
; It will set a flag to tell SPAZ which un-archiver to try and use.

ArchiveCheck    proc    near

    mov    AH,OpenFile            ;AH = open file request
    mov    AL,0                ;read access only
    mov    DX,offset cmd1            ;Point to archive name
    int    DOS                ;Call DOS to open it
    jc    probs

    xchg    AX,BX                ;Handle in BX
    mov    AH,ReadFile            ;AH = read file
    mov    CX,4                ;Read first 4 bytes
    mov    DX,offset Usage            ;Read byte into usage area
    int    DOS                ;Call DOS to do it
    jc    probs

    mov    AH,MoveFilePointer        ;Get ready to adjust
    mov    AL,2                ;From end of file
    mov    CX,0ffffh            ;2 spaces
    mov    DX,0fffeh
    int    DOS                ;Call DOS to do it
    jc    probs

    mov    AH,ReadFile            ;Read last 2 bytes
    mov    CX,2
    mov    DX,offset Usage + 4        ;Buffer for save
    int    DOS                ;Call DOS to do it
    jc    probs

    mov    AH,CloseFile            ;AH = close file
    int    DOS                ;Call DOS to do it
    jc    probs

    mov    AX,word ptr Usage + 4        ;Get DWC bytes
    cmp    AX,4357h            ;Is it a DWC file?
    jne    IsItZoo                ;Go, if not
    mov    IsDWC,true            ;Else set flag
    jmp    short EndCheck            ;And exit

IsItZoo:
    mov    AX,word ptr Usage        ;Get value
    cmp    AX,4f5ah            ;Is it a zoo file?
    jne    IsItZip                ;Go if not, else
    mov    zooflag,true            ;Mark for zoo
    jmp    short EndCheck

IsItZip:
    cmp    AX,4b50h            ;Is it a ZIP file?
    jne    IsItArc                ;Go, if not
    mov    IsZip,true            ;Set flag
    jmp    short EndCheck            ;We're outa here

IsItArc:
    cmp    AL,1Ah                ;Is it a normal Arc/Pak?
    jne    IsItLZH                ;Skip this file if not
    jmp    short EndCheck            ;We're outa here

IsItLZH:
    mov    AX,word ptr Usage + 2        ;Get LH's ID bytes
    cmp    AX,6C2Dh            ;Is this an LH Arc?
    jne    NotAnArchive            ;Report error if not
    mov    IsLZH,true            ;Mark for LHArc
EndCheck:
    clc                    ;Show no errors
    ret

probs:    push    AX                ;Save error code
    call    err_msg                ;Report error in english
    mov    SI,offset zerr            ;SI = Zoo check error message
    call    ShowIt                ;Display it
    pop    AX                ;Restore error code
NotAnArchive:
    stc                    ;Show error
    ret                    ;Return to caller

ArchiveCheck    endp


; This routine is responsible for sorting ARCType bundles into proper
; FidoNet Mail format. i.e. Sorted by date/time. It is accomplished
; by sorting all the headers and re-writting the entire archive...

Sort_It    proc    near
    cld                    ;Move forward again...
    xor    AL,AL
    mov    num_hdr,AL            ;Init header counter
    mov    flag,false

    mov    DX,offset cmd1            ;DX = Archive filename

    mov    AH,OpenFile            ;AX = Open file
    xor    AL,AL                ;Normal Attribute
    int    DOS                ;Give it to DOS
    jnc    open_ok                ;Continue if it worked
    jmp    short inv_hdr            ;Go report errors


; This routine will read in the archive file headers so that they
; can be sorted.

open_ok:
    mov    in_handle,AX            ;Save file handle
    mov    buf_pos,0            ;Init buffer position
    call    read_hdr            ;Read in first header
    jnc    got_1st                ;If clear, we're OK

; Truncated file. Somethings weird in Denmark!

    mov    AX,19                ;Truncated file
inv_hdr:
    call    err_msg                ;Put it on screen
    stc
    ret                    ;Exit Sort_It with error


; If we get this far, the first header has been read in. Stuff it in
; the buffer and go for the rest...

got_1st:
    mov    SI,cmdtail            ;Point to arc data
    cmp    byte ptr [SI+1],0        ;End of Archive?
    jne    Chk_Crushed            ;Exit for sort
    jmp    got_em
Chk_Crushed:
    cmp    byte ptr [SI+1],10        ;Crushed file?
    jb    Not_Crushed            ;Nope, continue
    mov    Crushed,true            ;Else, show crushed
Not_Crushed:
    cmp    byte ptr [SI],1ah        ;Do we have a PAK file?
    je    pak_ok                ;If yes, keep going
    mov    AX,20                ;Invalid header
    call    err_msg                ;Report error in english
    add    sp,2                ;Remove return address
    mov    AH,CloseFile            ;Close the file
    mov    BX,in_handle
    int    DOS                ;Call DOS to close file
    mov    byte ptr elevel,1        ;Report error for no delete
    jmp    main                ;Bad file, try the next one

pak_ok:    mov    DI,offset hdr_buf        ;Get buffer address
    add    DI,[buf_pos]            ;Adjust to current pos
    mov    AX,low_pos            ;Get file pointer low word
    mov    [DI],AX                ;Stuff it in buffer
    mov    AX,high_pos            ;Get file pointer high word
    mov    [DI+2],AX            ;Stuff it in buffer
    add    DI,4                ;Adjust the pointer
    mov    CX,29                ;Length of archive header
    rep    movsb                ;Put info in buffer
    add    buf_pos,arc_len            ;Bump the buffer pointer

    inc    num_hdr
    cmp    num_hdr,Entries         ;Have we got too many?
    jb    room                ;Nope, continue...

    mov    AX,21                ;Too many archive entries
    jmp    nope                ;Report and exit

room:    call    read_next            ;Get next header
    jnc    got_1st                ;Go stuff it in buffer
    jmp    short got_em            ;Got all headers, exit

read_next:
    mov    DI,cmdtail            ;DI = start of header
    mov    DX,word ptr [DI+15]        ;DX = low byte of arc size
    mov    CX,word ptr [DI+17]        ;CX = high byte of arc size
    mov    BX,in_handle            ;BX = opened file handle
    mov    AH,MoveFilePointer        ;AH = move file pointer
    mov    AL,1                ;AL = from current position
    int    DOS                ;Give it to DOS
read_hdr:
    mov    BX,in_handle            ;Get opened file handle
    xor    CX,CX                ;Set offset for search
    xor    DX,DX                ; to zero bytes
    mov    AH,MoveFilePointer        ;AH = move file pointrr
    mov    AL,1                ;AL = from currcnt position
    int    DOS                ;Call DOS to do it
    mov    high_pos,DX            ;Save the high word
    mov    low_pos,AX            ;Save the low word
    mov BX,in_handle            ;Get opened file handle
    mov    CX,29                ;Read in 29 bytes
    mov    DX,cmdtail            ;Buffer for read...
    mov    AH,ReadFile            ;Read from file
    int    DOS                ;Give it to DOS
    ret

got_em:    mov    Order,true            ;Archive already in order

    cmp    byte ptr N_Flag,false        ;Skip sort?
    jne    sort                ;If yes, exit
    mov    BX,in_handle            ;Get the file handle
    mov    AH,CloseFile            ;So we can close it
    int    DOS                ;Call DOS to do it
    jmp    Back_to_main            ;Exit sort

sort:    mov    flag,false            ;Show no changes made
    mov    count,1                ;To prevent sort past end
    mov    AH,num_hdr            ;Get number of entrys
    cmp    AH,1                ;Is there only 1 entry?
    jbe    sort_exit            ;No sort if 0 or 1 entry

    mov    SI,offset hdr_buf        ;SI = start of header buffer
    mov    DI,offset hdr_buf+arc_len    ;DI = 2nd entry in buffer
sort1:    mov    BX,23                ;BX = offset to header date
    mov    AX,[SI+BX]            ;Get date from 1st entry
    mov    DX,[DI+BX]            ;Got date from 2nd entry
    cmp    AX,DX                ;Which is higher?
    ja    change                ;Swap if 1st > 2nd
    jne    sort2                ;If not = get next entry
    mov    BX,25                ; else get offset to time
    mov    AX,[SI+BX]            ;Get time from 1st entry
    mov    DX,[DI+BX]            ;Get time from 2nd entry
    cmp    AX,DX                ;Which is higher?
    ja    change                ;Swap if 1st > 2nd

; If Date and Time are identical, no changes are made

sort2:    add    SI,arc_len            ;Point to next entry
    add    DI,arc_len            ;Point to next entry
    inc    count                ;Bump # of entries completed
    mov    AH,count            ;Get the number
    cmp    AH,num_hdr            ;Done all entries?
    je    pass                ;End of this pass if yes
    jmp    short sort1            ;Else do next entry

; This section will swap the entry pointed to by SI with the entry
; pointed to by DI...

change:    push    SI                ;Save pointer to 1st entry
    push    DI                ;Save pointer to 2nd entry
    mov    CX,arc_len            ;# of bytes in an entry
chg1:    mov    AL,[DI]                ;Get byte from destination
    movsb                    ;Move Source to Destination
    mov    [SI-1],AL            ;Move Destination to Source
    loop    chg1                ;Loop back for more
    pop    DI                ;Restore 2nd entry address
    pop    SI                ;Restore 1st entry address
    mov    flag,true            ;A swap has been made (pass)
    mov    Order,false            ;Show swap made (constant)
    jmp    sort2                ;Do next entry

; Here we check if a change was made. If no changes were made
; then the archive was already in order...

pass:    mov    AH,flag                ;Get the sort flag
    cmp    AH,true                ;Was a change made?
    je    sort                ;Go again if change was made

sort_exit:
    mov    AL,Order            ;Was archive in order?
    cmp    AL,true                ;If yes, do not write
    jne    write
    mov    BX,in_handle            ;Get the file handle
    mov    AH,CloseFile            ;So we can close it
    int    DOS                ;Call DOS to do it
    jmp    Back_to_main            ;The file out again.

write:
    mov    DI,offset tempspec        ;point to temp filespec  .jjn
    mov    SI,offset cmd1            ;get location of command .jjn
    mov    CX,pathlen            ;get path length         .jjn
    rep movsb                ;make a copy             .jjn
    mov    SI,offset temp            ;Point to temp filename  .jjn
    mov    CX,thomlen            ;get length of filename  .jjn
    rep movsb                ;copy it after the path  .jjn
    mov    DX,offset tempspec        ;Point to temp filespec  .jjn
    xor    CX,CX                ;Use normal attribute
    mov    AH,CreateFile            ;AH = create or truncate
    int    DOS                ;Call DOS to do it
    jnc    create_ok            ;Go if all is well
nope:    call    err_msg                ;Report error in english
    stc                    ;Carry = Sort failed
    ret                    ;Back to main section

; Here, the temp file has been created and the handle for that file is
; in AX.

create_ok:
    mov    out_handle,AX            ;Save handle for write file

; Now, we have to read in the sorted entry info, and gather more stuff
; from the archive headers

    mov    SI,offset hdr_buf        ;Point to the sorted info
    mov    AL,num_hdr            ;Get number of entries
nxt_hdr:
    mov    flag,false            ;Use flag for eof check
    push    AX                ;Save # of entries for later
    push    SI                ;Save buffer pointer
    mov    DX,[SI]                ;Get low word of file position
    mov    CX,[SI+2]            ;Get high word of position
    mov    low_pos,DX
    mov    high_pos,CX

    clc
    add    DX,29                ;Adjust for arc header
    adc    CX,0                ;Include carry if any

    mov    BX,in_handle            ;Get read file handle
    mov    AL,0                ;Offset is from beginning
    mov    AH,MoveFilePointer        ;AH = move file pointer
    int    DOS                ;Call DOS to do it

; The file pointer has been set to the read location. First we
; write the header. Then we read and write the archive data.

hdr_in:    call    info                ;Print the copy info
    pop    DX                ;Get buffer pointer
    push    DX                ;And save it again
    add    DX,4                ;Skip past file location
    mov    CX,29                ;Number of bytes to write
    mov    BX,out_handle            ;Get the write file handle
    mov    AH,WriteFile            ;AH = write to file
    int    DOS                ;Call DOS to write the header
    jnc    hdr_out                ;Header written ... go
    add    sp,4                ;Get rid of stack junk
    jmp    short nope            ;Exit, we had problems

hdr_out:
    pop    SI                ;Point to the header
    push    SI                ;Save it back
    mov    DX,[SI+21]            ;Get high word of entry size
    mov    AX,[SI+19]            ;Get low word of entry size

; DX:AX contains the number of bytes that have to be read/written.

    xor     CX,CX                ;High word of buffer size
    mov    BX,bsize            ;Low word of buffer size

; CX:BX contains the number of bytes we can do at one time.

cont:    clc                    ;Get ready for subtract
    sub    AX,BX                ;Subtract low word
    sbb    DX,CX                ;Subtract high word
    push    AX
    push    DX
    push    BX
    push    CX
    jae    more1                ;There's still more to go

    clc
    add    BX,AX                ;Add back last result
    mov    flag,true            ;Show end of data reached

; Here BX contains the remaining number of bytes to read write.
; So we have to put it in CX

more1:    xchg    BX,CX                ;Get count in CX
    mov    DX,offset cpy_buf        ;Point to our buffer
    mov    BX,in_handle            ;Handle for read
    mov    AH,ReadFile            ;AH = read file

; Note: CX should contain [bsize] OR the  remaining bytes to go...

    int    DOS                ;Call DOS to read file
    jnc    data_ok                ;Got the data
    add    sp,12                ;Remove stack junk
    jmp    nope                ;Exit, we had probs...

data_ok:
    mov    BX,out_handle            ;Handle for write
    mov    AH,WriteFile            ;AH = write to file
    int    DOS                ;Call DOS to write out buffer
    jnc    write_ok            ;Go if all is well, else
    add    sp,12                ;Remove junk from stack
    jmp    nope                ;Exit...

write_ok:
    cmp    flag,true            ;Was this end of arc data?
    je    do_next                ;Get next header if yes
    pop    CX                ;Low word buffer size
    pop    BX                ;Low word file size
    pop    DX                ;High word file size
    pop    AX                ;Low word buffer size
    jmp    cont                ;Continue with this entry
do_next:
    add    SP,8                ;Clear junk off stack
    pop    SI                ;Get back buffer position
    add    SI,33                ;Adjust to next entry
    pop    AX                ;Get back number of entrys
    dec    AL                ;Subtract 1 from it
    jz    no_more                ;We're done with data
    jmp    nxt_hdr                ;Else go get the next one
no_more:

; Before we quit, we have to write out a 1A 00 to show the end of
; the archive.

    mov    AH,WriteFile            ;AH = write to file
    mov    BX,out_handle            ;Handle for write file
    mov    CX,2                ;Number of bytes to write
    mov    DX,offset end_arc        ;Point to the data
    int    DOS                ;Call DOS to do it
    jnc    delete                ;We're finished !
    jmp    nope                ;Exit sort routine

; Now that the meat of the work is done, we have to delete the old
; arc file and rename the new one.

delete:    mov    BX,in_handle
    mov    AH,CloseFile
    int    DOS
    mov    BX,out_handle
    mov    AH,CloseFile
    int    DOS

    mov    DX,offset cmd1            ;Point to original name
    mov    AH,DeleteFile            ;AH = delete file
    int    DOS                ;Call DOS to do it
    jnc    del_ok
    jmp    nope

del_ok:    mov    AH,RenameFile            ;AH = rename file
    mov    DI,offset cmd1            ;Original filename
    mov    DX,offset tempspec        ;Temporary filename        .jjn
    int    DOS                ;Call DOS to do it
    jnc    Back_to_main            ;Go if no problems
    jmp    nope                ;Exit program...
Back_to_main:
    clc                    ;Sort done. No errors
    ret                    ;Return to main section

; Convert double word to ascii decimal. Uses divide instruction
; Parameters passed in registers as follows:
;    DX:AX =    binary word to be converted

DecimalOut:
    push    DI
    push    AX
    mov    DI,offset decbuf        ; address of output buffer
    mov    CX,7                ; buffer length-1
    mov    AL,' '                ; pad character
    rep    stosb                ; clear buffer & point to end
    mov    byte ptr [DI], 0        ; init end of string
    dec    DI
    pop    AX                ;Get low word back
    xchg    BP,DX                ;Save high word
    mov    BX,10                ;Use base 10 for decimal
    mov    CL,30h                ;For conversion to ASCII
HighWordLoop:
    or    BP,BP                ;Are we done with high words?
    jz    LowWordLoop            ;Yes
    xchg    AX,BP                ;No, get high word
    xor    DX,DX                ;Clear DX
    div    BX
    xchg    BP,AX                ;Save new high word
    div    BX                ;Divide low word + remainder
    or    DL,CL                ;Convert hex value to ASCII
    mov    [DI],DL                ;Save decimal character
    dec    DI                ;Back up in the buffer
    jmp    HighWordLoop            ;Repeat until done
LowWordLoop:
    xor    DX,DX                ;Clear DX
    div    BX
    or    DL,CL                ;Convert hex value to ASCII
    mov    [DI],DL                ;Save decimal character
    dec    DI                ;Back up in the buffer
    or    AX,AX                ;Are we done?
    jnz    LowWordLoop            ;No

    pop    DI
    ret
Sort_It    endp


;Convert an ASCIIZ string to upper case.
; Call with SI pointing to string to be converted

upper    proc    near
    push    SI                ; save string address
up1:    lodsb                    ; next character
        or    AL,AL                ; found end (null byte) ?
        jz      up2                ; yes, jump
        cmp     AL,'a'                ; test if in range 'a'-'z'
        jb      up1                ; skip it if not >= a
        cmp     AL,'z'
        ja      up1                ; skip it if not <= z
        sub     byte ptr [SI-1],'a'-'A'        ; change char to upper case
        jmp     up1                ; get another char

up2:    pop    SI                ; restore original string
    ret                    ; address and return
upper    endp


; This routine is called by the sort. It prints a line of information
; for every entry in the archive detailing its size, filename, and
; new locatio in the archive....

info    proc    near
    mov    SI,offset msg1            ;SI = 'Adjusting'
    call    ShowIt                ;Put it on screen
    mov    BP,SP                ;Get stack pointer
    mov    SI,[BP+2]            ;SI = address of arc entry
    add    SI,6                ;Now SI points to filename
    push    SI                ;Save address for later
    call    ShowIt                ;Put it on screen

    mov    CX,14                ;Tab length for info screen
    sub    CL,Characters            ;Subtract # of chars printed
    mov    DL,blank            ;AL = space
    mov    AH,CharacterOutput        ;Function = console out
info_loop:
    int    DOS                ;Call DOS to print space
    loop    info_loop            ;Loop till tab is complete

    mov    SI,offset msg2            ;SI = 'Location ='
    call    ShowIt                ;Put it on screen
    mov    DX,high_pos            ;High word file position
    mov    AX,low_pos            ;Low word file position
    call    DecimalOut            ;Convert to ASCII and print
    mov    SI,offset decbuf        ;Yes, String address to SI
    call    ShowIt                ; Output it
    mov    SI,offset msg3            ;SI = 'Length ='
    call    ShowIt                ;Put it on screen
    pop    SI                ;Restore Arc filename address
    mov    AX,[SI+13]            ;Low word file size
    mov    DX,[SI+15]            ;High word file size
    clc                    ;Get ready for addition
    add    AX,29                ;Add in length of header
    adc    DX,0                ;Add in any carry
    call    DecimalOut            ;Convert to ASCII and print
    mov    SI,offset decbuf        ;Yes, String address to SI
    call    ShowIt                ; Output it
    mov    SI,offset crlf            ;SI = cr/lf
    call    ShowIt                ;Put it on screen
    ret                    ;Return to caller
info    endp

; This routine prints one of DOS's error messages and returns to
; which ever section of the code called it...

err_msg    proc    near
    push    AX                ;Save errorlevel
    dec    AX                ;Adjust for beginning of table
    add    AX,AX                ; * 2 for DW variables
    mov    SI,AX                ;Get offset in SI
    mov    SI,errmsg[SI]            ;Now SI = address of string
    call    ShowIt                ;Put it on screen
    pop    AX                ;Restore errorlevel
    ret
err_msg    endp


;************************************************************************
; FindNames: find all file names matching the file specification in cmd1.
; REGISTERS ON EXIT:
;  AX = number of files found (may be 0).
;  ZF = reset if files found, set if no files found.
; This procedure written by Jeffrey J Nonken. (Modified by Dan)
;************************************************************************

    public    FindNames
FindNames    proc    near
    mov    DI,offset save_buf        ;Get dest addresm of filename
    mov    AL,num_names            ;Get # of names already there
    mov    CL,13                ;Length of 1 entry
    mul    CL                ;Names * 13
    add    DI,AX                ;Now DI points into buffer

    mov    AH,SearchForFirst        ;AH = Search for first
    xor    CX,CX                ;Attribute = 'normal'
    mov    DX,offset cmd1            ;Point to ASCIIZ filename
    int    DOS                ;Give it to DOS
    jnc    get1fname            ; Found a file, process it
    jmp    no_files            ;Finished with search

; Loop to here if buffer was written to disk.

clean_buf:
    mov    num_names,0            ; no more names in the buffer
    mov    DI,offset save_buf        ;Get dest address of filename

; Loop to here after each file name, look for the next one.

next:
    mov    AH,SearchForNext        ;AH = Search for next
    int    DOS                ;Give it to DOS
    jnc    get1fname            ; Found a file, process it
    jmp    short NoMoreFiles        ; If not, quit now.
get1fname:

;Now we move the filename.ext up to our own ASCIIZ string
;so that open can use the correct path to the file.

    mov    SI,offset dta_buf+30        ;SI = filename found
    mov    CX,6                ; Name is <= 13 bytes
                        ;  (including trailing null)
    rep movsw                ; Move 12 bytes (6 words)
    movsb                    ; Move the last byte
    inc    name_count            ; Count up (total count)
    inc    num_names            ; Count up (buffer count)
    cmp    num_names,NamesFound        ; See if we have names yet
    jb    next                ; Just repeat if not

; If we got here, there were at least 'NamesFound' names.
; Start writing them to disk.

    cmp    on_disk,0            ; See if there's a file open
    jnz    already_open            ; If so, skip the open step
    mov    DX,offset filename_file        ; Get the file's name
    mov    AH,CreateFile            ; Open the file
    xor    CX,CX                ;No attributes
    int    DOS                ; Do it
    mov    files_handle,AX            ; Save the file handle(error)
    jnc    already_open            ; If no errors, write to file
    call    err_msg                ;Report error in english
    mov    DX,offset TempErr        ;Unable to create file
    mov    AH,OutputString            ;DOS print string function
    int    DOS                ;Display error
    jmp    short NoMoreFiles        ;Continue on

; If the temporary file can't be created, we exit here. This will allow
; SPAZ to process at least 'NamesFound' archives before quitting. If this
; is a disk full condition, it will be reported by the un-archiver.

already_open:
    mov    DX,offset save_buf        ; point to buffer
    mov    BX,files_handle            ; get the file handle
    mov    CX,13 * NamesFound        ; number of file names to write
    mov    AH,WriteFile            ; write to the file
    int    DOS
    mov    on_disk,1            ; say it's on disk
    jmp    clean_buf            ; loop around and clear buffer

; No more files found. Clean up and exit.

NoMoreFiles:                    ; Last file was found
    cmp    on_disk,0            ; see if there is a files file
    jz    no_files            ; if not, just return
    cmp    num_names,0            ; see if any left in buffer
    jz    no_files
    mov    AL,num_names            ; Yes, get the number of names
    mov    BL,13                ; length of a name
    mul    BL                ; how many bytes to write
    mov    DX,offset save_buf        ; point to buffer
    mov    BX,files_handle            ; get the file handle
    mov    CX,AX                ; number of bytes to write
    mov    AH,WriteFile            ; write to the file
    int    DOS

; Hmmmmm. If disk is full, un-archiver will report error. If it's just
; a bad read/write, DOS's abort, retry, ignore will display. Don't
; think we have to check?

; All files (if any) have been found and buffered or written to disk. Save
; the address of the buffer in case we have files in the buffer. Restore the
; DTA.

no_files:
    mov    fname_ptr,offset save_buf    ;Address of scratch space
    mov    names_used,0            ; No names used yet
    ret
FindNames    endp

;****************************************************************************
; wild_card: Each time called this returns the next name in the list, if any.
;  It 'returns' it by copying it into the end of the command line buffer
;  after the path so it can be used immediatly. If it has no more names,
;  it exits the program.
; This procedure written by Jeffrey J. Nonken (and mangled by Dan)
;****************************************************************************
    public    wild_card
wild_card    proc    near
    mov    AX,names_used            ; Get number of names returned
    cmp    AX,name_count            ; Compare to total # of names
    jb    more_names            ; If less, we still have some

; We have no names left to return. See if they were on disk. If so, close up.

    cmp    on_disk,0            ; see if on disk
    jz    w_skip_close            ; if not, skip over the close
    mov    AH,CloseFile            ; close file command
    mov    BX,files_handle            ; get the file handle
    int    DOS
    mov    AH,DeleteFile            ; Delete file command
    mov    DX,offset filename_file        ; Name of file to delete
    int    DOS                ; Delete our scratch file
w_skip_close:
    mov    AL,elevel            ;Get last reported errorlevel
    mov    AH,ExitWithCode            ;Terminate with return code
    int    DOS                ;Exit program


; We still have names left. Let's see if they're on disk.

more_names:
    cmp    on_disk,0            ; Are they stored on disk?
    jz    not_on_disk            ; If not, get from the buffer.

; If we got here, the files are stored on disk. Read one name, 13 bytes, right
; into the file spec. The name was originally null terminated, so extra junk
; on the end won't matter.

    mov    AH,ReadFile            ; Read file command
    mov    BX,files_handle            ; get the file handle
    mov    DX,endpath            ;Get end address of path
    mov    CX,13                ; Read 1 filename
    int    DOS
    jnc    w_got1                ; If no carry, we got it

; If we can't process the temp file, SPAZ has no filenames to work with.
; The only safe thing to do, is exit with the errorlevel. This will leave
; any archives intact so they can be handled later.

    call    err_msg                ;Report error in english
    mov    DX,offset TempErr        ;Error processing temp file
    mov    AH,OutputString            ;DOS print string function
    int    DOS                ;Display error
    mov    AH,ExitWithCode            ;Terminate SPAZ
    int    DOS                ;Tell DOS to do it


; If we got here, there are four or fewer filenames, and they are in the
; scratch buffer. fname_ptr points to the current filename. Just copy all
; 13 bytes in; as before, the name was already null terminated.

not_on_disk:
    push    SI                ; Save the index registers
    push    DI
    mov    SI,fname_ptr            ; get the current source ptr
    mov    DI,endpath            ; Get end address of path
    mov    CX,6                ; copy 12 bytes (6 words)
    rep movsw
    movsb                    ; copy the 13th byte
    mov    fname_ptr,SI            ; save the new pointer
    pop    DI                ; restore the index registers
    pop    SI

; One way or another, we copied a filename.

w_got1:
    inc    names_used            ; Note that we used a name
    clc                    ; Clear the carry flag
    ret
wild_card    endp


; The following routine scans each command line option and sets various
; flags according to options used.

options    proc    near
    cld                    ;Ensure forward movements
    xor    AX,AX                ;Start with argument 1
Opt0:    inc    AX                ;Bump argument number
    push    AX                ;Save argument number
    mov    BX,cmdtail            ;Point BX to command line
    call    argv                ;Get info on argument
    or    AX,AX                ;Did we find an argument?
    jnz    StillMore
    jmp    end_Opts            ;Nope, we must be done...
StillMore:
    push    AX                ;Save argument length
    mov    SI,BX                ;Address in SI
    call    upper                ;Convert to upper case
    lodsb                    ;Get first character
    cmp    AL,'/'                ;Is this an option?
    je    Opt1                ;Go get it if yes
    cmp    AL,'-'                ;Option?
    jne    arc_name            ;Get archive name
Opt1:    pop    AX                ;Get argument length back
    push    AX                ;Maintain stack balance
    cmp    AX,2                ;Check for valid size
    jne    bad_opt                ;Report bad option
    lodsb                    ;Get option ID
    cmp    AL,'D'                ;Delete flag?
    jne    Opt2                ;Next check if not
    mov    byte ptr D_Flag,true        ;Set flag to delete arc's
    jmp    short nxt_opt            ;Do next option
Opt2:    cmp    AL,'N'                ;Sort flag?
    jne    Opt3                ;Next check if not
    mov    byte ptr N_Flag,false        ;Set flag for no sort
    jmp    short nxt_opt            ;Do next option
Opt3:    cmp    AL,'A'                ;Default arc program flag?
    jne    Opt4                ;Next check if not
    mov    byte ptr A_Flag,true        ;Set flag to show default set
    jmp    short nxt_opt            ;Do next option
Opt4:    cmp    AL,'V'                ;Verbose mode desired?
    jne    Opt5                ;Next check if not
    mov    byte ptr Q_Flag,false        ;**Kludge** inverted quiet
    jmp    short nxt_opt            ;Do next option
Opt5:    cmp    AL,'F'                ;Is this a mail run?
    jne    Opt6                ;Report bad option if not
    mov    byte ptr F_Flag,true        ;Set up for mail run
    jmp    short nxt_opt            ;Do next option
Opt6:    cmp    AL,'O'                ;Overwrite mode?
    jne    Opt7                ;Make 1 more check
    mov    byte ptr O_Flag,true        ;Set overwrite mode
    jmp    short nxt_opt
Opt7:    cmp    AL,'R'                ;For Opus compatibility
    jne    bad_opt             ;Report bad option if not
    mov    byte ptr O_Flag,true        ;Set overwrite mode
    jmp    short nxt_opt
bad_opt:
    call    CheckMFlag            ;Are we expanding addresses?
    jnc    Nxt_Opt                ;It's Ok, keep going
    mov    AX,23                ;Unknow option used...
    call    err_msg                ;Report it
    jmp    syntax                ;Show syntax screen and exit

arc_name:
    pop    AX                ;Get length back
    push    AX                ;Maintain stack balance
    cmp    byte ptr Got_name,true        ;Do we have an archive name?
    jne    arc_name1            ;Nope, go get it
    call    parse_line            ;Yup, pass it the filenames...
    jmp    short nxt_opt            ;Continue with options

arc_name1:
    mov    Opt_Address,BX            ;Save address of file name
    mov    Opt_Length,AX            ;Save length of file name
    mov    byte ptr Got_name,true        ;Set flag to show we got it!

nxt_opt:
    pop    AX                ;Remove argument length
    pop    AX                ;Get arg number to work on
    jmp    Opt0                ;Continue...

end_Opts:
    add    SP,2                ;Clean off stack junk
    cmp    byte ptr Got_name,true        ;Did we get a filename?
    jne    bad_line            ;Report error if not
    cmp    F_Flag,true            ;Is this a mail run?
    jne    RestoreArg            ;Go if not
    mov    byte ptr D_Flag,true        ;Set auto delete
    mov    byte ptr N_Flag,true        ;Force an archive sort
    mov    byte ptr O_Flag,true        ;Force overwrite mode
RestoreArg:
    mov    AX,Opt_Length            ;Get length of argument
    mov    BX,Opt_Address            ;Get address of argument
    ret                    ;And we are outa' here..

;If the program falls through to here, all arguments were examined and
;an archive name was NOT found. Report an error, show the syntax screen
;and quit. What else can we do?

bad_line:
    mov    AX,24
    call    err_msg
    jmp    syntax
options    endp


CheckMFlag    proc    near

    lodsb                    ;Get next character
    cmp    AL,'M'                ;Is this the M flag?
    jne    NotTheMFlag            ;Exit if no
    call    DecimalIn            ;Get net number
    mov    word ptr OurNet,DX        ;Save it
    call    DecimalIn            ;Get node number
    mov    word ptr OurNode,DX        ;Save it
    mov    M_Flag,true            ;Set our flag
    clc                    ;Show we processed it
    ret                    ;And exit
NotTheMFlag:
    stc                    ;Oops, a boo-boo...
    ret                    ;Back to caller

CheckMFlag    endp


; This routine displays the current settings of the command line
; parameters. i.e. will sort, will not delete etc...

show_opt    proc    near
    push    AX
    push    BX

    cmp    byte ptr Q_Flag,true        ;Quiet mode?
    jne    NotQuietMode
    jmp    show_x                ;Exit if yes

NotQuietMode:
    cld                    ;Ensure forward movements
    mov    SI,offset will            ;Point to will message
    cmp    byte ptr A_Flag,true        ;Use Arce?
    je    show1
    mov    SI,offset wont
show1:    call    ShowIt
    mov    SI,offset info1
    call    ShowIt

    mov    SI,offset will
    cmp    byte ptr D_Flag,true        ;Delete archives?
    je    show2
    mov    SI,offset wont
show2:    call    ShowIt
    mov    SI,offset info2
    call    ShowIt

    mov    SI,offset will
    cmp    M_Flag,true            ;Expand net address?
    je    show3
    mov    SI,offset wont
show3:    call    ShowIt
    mov    SI,offset info5
    call    ShowIt

    mov    SI,offset will
    cmp    F_Flag,true            ;A mail run?
    je    show4
    mov    SI,offset wont
show4:    call    ShowIt
    mov    SI,offset info6
    call    ShowIt

    mov    SI,offset will
    cmp    byte ptr O_Flag,true        ;Force overwrite mode?
    je    show5
    mov    SI,offset wont
show5:    call    ShowIt
    mov    SI,offset info7
    call    ShowIt

    mov    SI,offset will
    cmp    byte ptr N_Flag,true        ;Sort archive?
    je    show6
    mov    SI,offset wont
show6:    call    ShowIt
    mov    SI,offset info3
    call    ShowIt

show_x:    pop    BX
    pop    AX
    ret
show_opt    endp


; This procedure converts an ASCII number to it's binary form. The
; routine will exit when the first non-ascii-number is reached. The
; binary value is returned in DX.

DecimalIn    proc    near

    xor    DX,DX                ;Initialize variable
DecimalLoop:
    lodsb                    ;Get first character
    sub    AL,30h                ;Subtract ASCII base
    jl    DecimalExit            ;If too low, we're finished
    cmp    AL,9
    jg    DecimalExit            ;If too high, we're finished
    cbw                    ;Convert to word value
    push    AX                ;Save digit
    mov    AX,DX
    mov    CX,10                ;Working with base 10
    mul    CX                ; 10 * digit
    mov    DX,AX                ;Result in DX
    pop    AX                ;Get number back
    add    DX,AX                ;Add number in
    jmp    short DecimalLoop        ;Get next digit
DecimalExit:
    ret                    ;Back to main section

DecimalIn    endp


; This routine parses filenames from the command line that must be passed
; to the unarchive program.

parse_line    proc    near
    cld                    ;Go in the right direction!
    mov    Parsed,true            ;Show names were parsed
    mov    CX,word ptr Names_Count        ;Get current character count
    push    AX                ;Save argument length
    add    AX,CX                ;AX = new length total
    mov    SI,BX                ;Argument address to source
    mov    DI,offset Extract_Names        ;DI = buffer address
    add    DI,CX                ;Adjust to current position
    mov    byte ptr [DI],blank        ;Add in a space
    inc    DI                ;Adjust pointer
    inc    AX                ;Add 1 to total length
    mov    word ptr Names_Count,AX        ;Save new total length
    pop    CX                ;Get argument length in CX
    rep    movsb                ;Move extract name into buffer
    mov    byte ptr [DI],0            ;End it with a null
    ret
parse_line    endp


DisplayNode    proc    near

    cmp    M_Flag,true            ;Should we do this?
    jne    ExitDisplayNode            ;Exit if not

    mov    SI,endpath            ;Point to bundle name
    call    GetFromAddress            ;Decode the Address
    mov    DI,offset BuildNet        ;Where to store it
    mov    AX,word ptr FromNet        ;Get the Senders net
    mov    DX,word ptr OurNet        ;Get our own net
    add    AX,DX                ;Figure out the difference
    xor    DX,DX                ;Get ready for conversion
    call    DecimalOut            ;Convert to ASCII
    call    InsertAddress            ;Add Net number to string
    mov    AL,'/'                ;Address delimiter
    stosb                    ;Stuff it in
    mov    AX,word ptr FromNode        ;Get the Senders node
    mov    DX,word ptr OurNode        ;Get our node address
    add    AX,DX                ;Figure out the difference
    xor    DX,DX                ;Get ready for conversion
    call    DecimalOut            ;Convert to ASCII
    call    InsertAddress            ;Add node number to string
    mov    byte ptr [DI],0            ;Make it ASCIIZ
ExitDisplayNode:
    ret                    ;Back to main

DisplayNode    endp


InsertAddress    proc    near

    mov    SI,offset DecBuf        ;Point to ASCII buffer
Insert1:
    lodsb                    ;Get a byte
    cmp    AL,blank            ;Is it ASCII space?
    je    Insert1                ;Loop if yes
Insert2:
    stosb                    ;Not 0, we keep it...
    lodsb                    ;And get another
    or    AL,AL                ;Check for end
    jnz    Insert2                ;Loop till finished
    ret                    ;Back to caller

InsertAddress    endp


GetFromAddress    proc    near

    call    GetNet                ;Get the net bundle is from
    mov    word ptr FromNet,DX        ;And save it
    call    GetNet                ;Get the node number
    mov    word ptr FromNode,DX        ;And save it
    ret                    ;That's it!
GetNet:
    xor    DX,DX                ;Start with 0
    mov    CX,4                ;Counter for Hex number
Net1:    lodsb                    ;Grab a byte
    sub    AL,30h                ;Mask off the ASCII
    jl    Net3                ;Too low, exit
    cmp    AL,9                ;0 to 9?
    jle    Net2                ;If yes, no adjustment
    and    AL,5fh                ;Mask off the casing
    sub    AL,7                ;Adjust for A-F
    jl    Net3                ;Quit if too low
    cmp    AL,15                ;Higher than F?
    jg    Net3                ;Quit if too high
Net2:    push    CX                ;Save character counter
    cbw                    ;Sign extend our number
    mov    CL,4                ;4 bits per hex character
    sal    DX,CL                ;Shift over previous value
    add    DX,AX                ;And add in the new
    pop    CX                ;Restore character counter
    loop    Net1                ;Do 4 characters
Net3:    ret                    ;And then exit

GetFromAddress    endp


BuildNet    equ    $            ;Buffer for Net/Node
FromNet        equ    BuildNet + 12        ;Sending Net
FromNode    equ    FromNet + 2        ;Sending Node
OurNet        equ    FromNode + 2        ;Our Net
OurNode        equ    OurNet + 2        ;Our Node
cpy_buf        equ    OurNode + 2        ;Storage for copy buffer
hdr_buf        equ    cpy_buf + bsize        ;Buffer to hold headers
cmd1    equ    hdr_buf + entries * arc_len    ;Buffer for wildcard filenames
new        equ    cmd1 + 80        ;Buffer for Arc path search
saved        equ    new + 80        ;Buffer for Arc exec
decbuf        equ    saved + 192        ;Buffer for decimal conversions
dta_buf        equ    decbuf + 8        ;Disk Transfer Area
Def_Arc        equ    dta_buf + 43        ;Default Archive Name
Fcb1        equ    Def_Arc + 13        ;File Control Block 1
Fcb2        equ    Fcb1 + 37        ;File control Block 2
Cmd_Cnt        equ    Fcb2 + 37        ;Command Line Char Counter
ExtractOptions    equ    Cmd_Cnt + 1        ;Options to pass to Un-Archer
Pakfile     equ    ExtractOptions + 9    ;Filenames to pass to Un-Archer
Extract_Names    equ    Pakfile + 160        ;Buffer for names to extract
Names_Count    equ    Extract_Names + 128    ;Count for names to extract
tempspec    equ    Names_Count + 2        ;Scratch for temp filespec .jjn
save_buf    equ    tempspec + 80        ; Filename buffer          .jjn
stk    equ    save_buf + (13 * NamesFound)    ;Stack Area                .jjn
bottom        equ    stk + 200        ;End of code and data

cseg    ends

    end    entry